home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Gold Collection / Software Vault - The Gold Collection (American Databankers) (1993).ISO / cdr25 / stdapp.zip / STDAPP.C < prev    next >
C/C++ Source or Header  |  1993-03-05  |  35KB  |  1,264 lines
  1. #define  INCL_PM
  2. #define  INCL_DOS
  3.  
  4. #include <os2.h>
  5. #include "stdappi.h"
  6.  
  7.  
  8.  
  9.  
  10. VOID HlpDisplayHelpPanel(PPRVSTDAPP pPrvStdApp, SHORT idPanel);
  11.  
  12.  
  13.  
  14. BOOL       ValidateMenuHelpStdApp( PPRVSTDAPP pPrvStdApp );
  15. BOOL       ValidateMenuExitStdApp( PPRVSTDAPP pPrvStdApp );
  16. BOOL       ValidateMenuStdApp(PPRVSTDAPP pPrvStdApp);
  17. BOOL       ValidateMenuServiceStdApp( PPRVSTDAPP pPrvStdApp );
  18. MRESULT    CommandStdApp(HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2);
  19. MRESULT    InitMenuStdApp(HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2);
  20.  
  21.  
  22. VOID       APIENTRY  EnableMenuItemStdApp( HWND hwndMenu
  23.                                          , SHORT sIditem
  24.                                          , BOOL bEnable);
  25. HAB        APIENTRY  QueryHabStdApp( PPUBSTDAPP pPubStdApp );
  26. HPS        APIENTRY  QueryHpsStdApp( PPUBSTDAPP pPubStdApp );
  27. HWND       APIENTRY  QueryFrameStdApp( PPUBSTDAPP pPubStdApp );
  28. HWND       APIENTRY  QueryClientStdApp( PPUBSTDAPP pPubStdApp );
  29. BOOL       APIENTRY  MsgLoopStdApp( PPUBSTDAPP pPubStdApp );
  30. BOOL       APIENTRY  QueryDevResStdApp( PPUBSTDAPP pPubStdApp
  31.                                       , PULONG pulXRes
  32.                                       , PULONG pulYRes );
  33. BOOL       APIENTRY  QueryDevColorStdApp( PPUBSTDAPP pPubStdApp
  34.                                         , PULONG pulColorPlanes
  35.                                         , PULONG pulColorBitcount );
  36. PPUBSTDAPP APIENTRY  DeleteStdApp( PPUBSTDAPP pPubStdApp );
  37. MRESULT    EXPENTRY  ProcStdApp(HWND hwnd, USHORT msg, MPARAM mp1
  38.                                , MPARAM mp2);
  39.  
  40.  
  41.  
  42. PPUBSTDAPP APIENTRY
  43. NewStdApp( PVOID pvUserProc, ULONG flExclude, ULONG flServices)
  44. {
  45.    SWP         swpFrame;
  46.    FRAMECDATA  fcData;
  47.    PPRVSTDAPP  pPrvStdApp;
  48.    PPUBSTDAPP  pPubStdApp;
  49.    BOOL        fRc;
  50.  
  51.  
  52.    pPubStdApp = (PPUBSTDAPP)calloc( 1, sizeof(PUBSTDAPP) );
  53.    if ( pPubStdApp )
  54.    {
  55.       pPrvStdApp = (PPRVSTDAPP)calloc( 1, sizeof(PRVSTDAPP) );
  56.       if ( pPrvStdApp )
  57.       {
  58.          APIRET apiret;
  59.          // Our private data.
  60.          pPubStdApp->pv = pPrvStdApp;
  61.  
  62.  
  63.  
  64.          pPrvStdApp->hab = WinInitialize(0);
  65.          if ( !pPrvStdApp->hab )
  66.             goto ErrorDrain;
  67.  
  68.          pPrvStdApp->hmq = WinCreateMsgQueue(pPrvStdApp->hab, 0);
  69.          if ( !pPrvStdApp->hmq )
  70.             goto ErrorDrain;
  71.  
  72.          fRc = UtlLoadString( pPrvStdApp->hab
  73.                             , pPrvStdApp->hmodExe
  74.                             , STDAPP_IDS_WIN_CLASSNAME
  75.                             , MAXNAMEL
  76.                             , pPrvStdApp->szClassName);
  77.          if ( fRc == API_FAILED )
  78.             goto ErrorDrain;
  79.  
  80.  
  81.  
  82.          fRc = UtlLoadString( pPrvStdApp->hab
  83.                             , pPrvStdApp->hmodExe
  84.                             , STDAPP_IDS_WIN_TITLE
  85.                             , MAXNAMEL
  86.                             , pPrvStdApp->szTitle);
  87.  
  88.          if ( fRc == API_FAILED )
  89.             strcpy(pPrvStdApp->szTitle, pPrvStdApp->szClassName);
  90.  
  91.  
  92.          fRc = WinRegisterClass( pPrvStdApp->hab
  93.                                , (PSZ)pPrvStdApp->szClassName
  94.                                , (PFNWP)ProcStdApp
  95.                                , CS_SIZEREDRAW| CS_CLIPCHILDREN
  96.          // An Extra two pointer slots are allocated.
  97.          // The first is for the
  98.          // user to have access to the slot indexed by
  99.          // QWL_USER and the second
  100.          // to hold pPubStdApp for our wndproc.
  101.                                , (sizeof(PVOID) * 2) );
  102.          if ( !fRc )
  103.             goto ErrorDrain;
  104.  
  105.          // Is module loaded ?
  106.          apiret = DosQueryModuleHandle( SERVICE_DLL_FULLNAME
  107.                                       , &pPrvStdApp->hmodDll );
  108.          if (apiret)
  109.          {
  110.             // Module not loaded let's try to load.
  111.             apiret = DosLoadModule ( pPrvStdApp->szText1
  112.                                    , STDAPP_TEXT_LENGTH
  113.                                    , SERVICE_DLL_NAME
  114.                                    , &pPrvStdApp->hmodDll );
  115.             if (apiret)
  116.             {
  117.                UtlUserMsgBox( "Failed to load StdApp module."
  118.                             , "StdApp Service"
  119.                             , MB_ENTER | MB_ERROR
  120.                             , TRUE
  121.                             , 0 );
  122.  
  123.                goto ErrorDrain ;
  124.             }
  125.          }
  126.  
  127.          // set frame control data
  128.          fcData.cb            = sizeof( fcData );
  129.          fcData.hmodResources = (HMODULE)0;
  130.          fcData.idResources   = STDAPP_IDR_WIN;
  131.  
  132.          // set the default frame window flags
  133.          //ulCtlData = FCF_STANDARD;
  134.          fcData.flCreateFlags = FCF_TITLEBAR      | FCF_SYSMENU  |
  135.                                 FCF_SIZEBORDER    | FCF_MINMAX   |
  136.                                 FCF_SHELLPOSITION | FCF_TASKLIST |
  137.                                 FCF_MENU          | FCF_ICON     |
  138.                                 FCF_ACCELTABLE    ;
  139.  
  140.          // give a caller chance to remove some standard frame controls.
  141.          fcData.flCreateFlags &= ~(flExclude);
  142.  
  143.          pPrvStdApp->flServices = flServices;
  144.  
  145.          WinQueryTaskSizePos( pPrvStdApp->hab, 0, &swpFrame );
  146.  
  147.          pPrvStdApp->hFrame = WinCreateWindow( HWND_DESKTOP
  148.                                              , WC_FRAME
  149.                                              , pPrvStdApp->szTitle
  150.                                              , 0UL
  151.                                              , swpFrame.x
  152.                                              , swpFrame.y
  153.                                              , swpFrame.cx
  154.                                              , swpFrame.cy
  155.                                              , (HWND)0
  156.                                              , HWND_TOP
  157.                                              , STDAPP_IDR_WIN
  158.                                              , &fcData
  159.                                              , (PVOID)0);
  160.  
  161.          if (!pPrvStdApp->hFrame)
  162.          {
  163.             fRc = UtlLoadMessage( pPrvStdApp->hab
  164.                                 , pPrvStdApp->hmodDll
  165.                                 , IDMSG_FRAMEWINCREATEFAILED
  166.                                 , STDAPP_TEXT_LENGTH
  167.                                 , pPrvStdApp->szText1);
  168.  
  169.             if ( fRc ==API_SUCCESS )
  170.               UtlDisplayError( pPrvStdApp->hab, pPrvStdApp->szText1);
  171.  
  172.             goto ErrorDrain;
  173.          }
  174.  
  175.          pPrvStdApp->hClient = WinCreateWindow( pPrvStdApp->hFrame
  176.                                               , (PSZ)pPrvStdApp->szClassName
  177.                                               , (PSZ)0
  178.                                               , 0UL
  179.                                               , 0
  180.                                               , 0
  181.                                               , 0
  182.                                               , 0
  183.                                               , pPrvStdApp->hFrame
  184.                                               , HWND_BOTTOM
  185.                                               , FID_CLIENT
  186.                                               , (PVOID)pPubStdApp
  187.                                               , (PVOID)0 );
  188.  
  189.  
  190.          if (!pPrvStdApp->hClient)
  191.          {
  192.             fRc = UtlLoadMessage( pPrvStdApp->hab
  193.                                 , pPrvStdApp->hmodDll
  194.                                 , IDMSG_CLIENTWINCREATEFAILED
  195.                                 , STDAPP_TEXT_LENGTH
  196.                                 , pPrvStdApp->szText1);
  197.  
  198.             if ( fRc ==API_SUCCESS )
  199.               UtlDisplayError( pPrvStdApp->hab, pPrvStdApp->szText1);
  200.  
  201.             goto ErrorDrain;
  202.          }
  203.  
  204.          pPrvStdApp->pfnUserProc = (PFNWP)pvUserProc;
  205.          WinSetWindowPtr( pPrvStdApp->hClient, STDAPP_PTR_INDEX, pPubStdApp );
  206.          UtlLoadMessage( pPrvStdApp->hab
  207.                        , pPrvStdApp->hmodDll
  208.                        , IDMSG_STDAPPSERVICE
  209.                        , STDAPP_TEXT_LENGTH
  210.                        , pPrvStdApp->szStdAppService );
  211.  
  212.  
  213.          if (flServices & STDAPP_SERVICE_HELP || STDAPP_SERVICE_CONFIRM_EXIT)
  214.          {
  215.  
  216.             ValidateMenuServiceStdApp( pPrvStdApp );
  217.          }
  218.  
  219.          if (flServices & STDAPP_SERVICE_HPS)
  220.          {
  221.             SIZEL  sizl;
  222.  
  223.             pPrvStdApp->hdcClient = WinOpenWindowDC(pPrvStdApp->hClient);
  224.             if (pPrvStdApp->hdcClient )
  225.             {
  226.                 pPrvStdApp->hpsClient = GpiCreatePS( pPrvStdApp->hab
  227.                                                    , pPrvStdApp->hdcClient
  228.                                                    , &sizl
  229.                                                    , PU_ARBITRARY
  230.                                                    | GPIT_MICRO
  231.                                                    | GPIA_ASSOC);
  232.  
  233.                 if ( pPrvStdApp->hpsClient )
  234.                 {
  235.                    if ( flServices & STDAPP_SERVICE_RGB )
  236.                       GpiCreateLogColorTable( pPrvStdApp->hpsClient
  237.                                             , 0L
  238.                                             , LCOLF_RGB
  239.                                             , 0L
  240.                                             , 0L
  241.                                             , (PLONG)NULL);
  242.  
  243.                    if (flServices & STDAPP_SERVICE_DEVRES)
  244.                    {
  245.                       // get the device resolutions
  246.                       DevQueryCaps( pPrvStdApp->hdcClient
  247.                                   , (LONG)CAPS_VERTICAL_RESOLUTION
  248.                                   , 1L
  249.                                   , &pPrvStdApp->cyRes);
  250.  
  251.                       DevQueryCaps( pPrvStdApp->hdcClient
  252.                                   , CAPS_HORIZONTAL_RESOLUTION
  253.                                   , 1L
  254.                                   , &pPrvStdApp->cxRes);
  255.  
  256.                       DevQueryCaps( pPrvStdApp->hdcClient
  257.                                   , CAPS_COLOR_PLANES
  258.                                   , 1L
  259.                                   , &pPrvStdApp->cColorPlanes);
  260.  
  261.                       DevQueryCaps( pPrvStdApp->hdcClient
  262.                                   , CAPS_COLOR_BITCOUNT
  263.                                   , 1L
  264.                                   , &pPrvStdApp->cColorBitcount);
  265.                    }
  266.                 }
  267.             }
  268.          }
  269.  
  270. //         WinInvalidateRect(pPrvStdApp->hFrame, (PRECTL)0, TRUE);
  271.  
  272.          WinShowWindow( pPrvStdApp->hFrame, TRUE );
  273.  
  274. //         WinShowWindow( pPrvStdApp->hClient, TRUE );
  275.  
  276.          // Callers methods
  277.          pPubStdApp->pfnMsgLoop       = MsgLoopStdApp;
  278.          pPubStdApp->pfnDelete        = DeleteStdApp;
  279.          pPubStdApp->pfnQueryHps      = QueryHpsStdApp;
  280.          pPubStdApp->pfnQueryHab      = QueryHabStdApp;
  281.          pPubStdApp->pfnQueryFrame    = QueryFrameStdApp;
  282.          pPubStdApp->pfnQueryClient   = QueryClientStdApp;
  283.          pPubStdApp->pfnQueryDevColor = QueryDevColorStdApp;
  284.          pPubStdApp->pfnQueryDevRes   = QueryDevResStdApp;
  285.       }
  286.       else
  287.       {
  288.          free(pPubStdApp);
  289.  
  290.          return (PPUBSTDAPP)0;
  291.       }
  292.    }
  293.  
  294.    return pPubStdApp;
  295.  
  296. ErrorDrain:
  297.  
  298.    pPubStdApp = DeleteStdApp(pPubStdApp);
  299.  
  300.    return pPubStdApp;
  301.  
  302. }  // end NewStdApp()
  303.  
  304.  
  305.  
  306.  
  307.  
  308.  
  309. MRESULT EXPENTRY
  310. ProcStdApp(HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2)
  311. {
  312.    MRESULT    mr;
  313.  
  314.    PPUBSTDAPP pPubStdApp = WinQueryWindowPtr( hwnd, STDAPP_PTR_INDEX);
  315.    PPRVSTDAPP pPrvStdApp = (PPRVSTDAPP)0;
  316.    BOOL       fReturnMr = FALSE;
  317.  
  318.    if ( pPubStdApp && pPubStdApp->pv )
  319.       pPrvStdApp = pPubStdApp->pv;
  320.  
  321.    switch(msg)
  322.    {
  323.  
  324.       case HM_QUERY_KEYS_HELP:
  325.       {
  326.          // return id of key help panel
  327.          mr = (MRESULT)STDAPP_PANEL_HELPKEYS;
  328.          fReturnMr = TRUE;
  329.          break;
  330.       }
  331.  
  332.  
  333.       case WM_COMMAND:
  334.       {
  335.          mr = CommandStdApp( hwnd, msg, mp1, mp2);
  336.          fReturnMr = TRUE;
  337.          break;
  338.       }
  339.  
  340.       case WM_INITMENU:
  341.       {
  342.          mr = InitMenuStdApp(hwnd, msg, mp1, mp2);
  343.          fReturnMr = TRUE;
  344.          break;
  345.       }
  346.  
  347.      // The party line !
  348.      // Any messages not processed are passed on
  349.      // to the user's window proc.  It is
  350.      // responsible for passing any messages it
  351.      // doesn't handle onto WinDefWindowProc()
  352.  
  353.       default:
  354.         // Fall through to exit code
  355.         break;
  356.    }
  357.  
  358.    if ( !fReturnMr )
  359.    {
  360.       if ( pPrvStdApp )
  361.          mr = pPrvStdApp->pfnUserProc(hwnd, msg, mp1, mp2);
  362.       else
  363.          mr = WinDefWindowProc( hwnd, msg, mp1, mp2);
  364.    }
  365.  
  366.    return mr;
  367.  
  368. }   // End of ProcStdApp()
  369.  
  370.  
  371.  
  372. // returns TRUE if msgloop executed atleast once
  373. BOOL APIENTRY
  374. MsgLoopStdApp(PPUBSTDAPP pPubStdApp)
  375. {
  376.    BOOL fRc = FALSE;
  377.  
  378.    if ( pPubStdApp && pPubStdApp->pv )
  379.    {
  380.       PPRVSTDAPP pPrvStdApp;
  381.       QMSG       qmsg;        // message structure
  382.  
  383.       pPrvStdApp = pPubStdApp->pv;
  384.  
  385.       while(WinGetMsg(pPrvStdApp->hmq, (PQMSG)&qmsg, (HWND)0, 0, 0))
  386.           WinDispatchMsg(pPrvStdApp->hmq, (PQMSG)&qmsg);
  387.  
  388.  
  389.       fRc = TRUE;
  390.    }
  391.  
  392.    return fRc;
  393.  
  394. }  // end MsgLoopStdApp()
  395.  
  396.  
  397. PPUBSTDAPP APIENTRY
  398. DeleteStdApp( PPUBSTDAPP pPubStdApp )
  399. {
  400.    if ( pPubStdApp && pPubStdApp->pv )
  401.    {
  402.       PPRVSTDAPP pPrvStdApp;
  403.  
  404.       pPrvStdApp = pPubStdApp->pv;
  405.       if ( pPrvStdApp )
  406.       {
  407.          if ( pPrvStdApp->flServices & STDAPP_SERVICE_HELP )
  408.             HlpDestroyHelpInstance(pPrvStdApp);
  409.  
  410.          // destroy the  window if it exists
  411.          if (WinIsWindow(pPrvStdApp->hab, pPrvStdApp->hFrame))
  412.             WinDestroyWindow(pPrvStdApp->hFrame);
  413.  
  414.          if ( pPrvStdApp->hmq )
  415.             WinDestroyMsgQueue(pPrvStdApp->hmq);
  416.  
  417.          if ( pPrvStdApp->hab )
  418.             WinTerminate(pPrvStdApp->hab);
  419.  
  420.          free(pPrvStdApp);
  421.       }
  422.  
  423.       free(pPubStdApp);
  424.    }
  425.  
  426.    return (PPUBSTDAPP)0;
  427.  
  428. }  // DeleteStdApp()
  429.  
  430.  
  431. HAB APIENTRY
  432. QueryHabStdApp( PPUBSTDAPP pPubStdApp )
  433. {
  434.    HAB hab = (HAB)0;
  435.  
  436.    if ( pPubStdApp && pPubStdApp->pv )
  437.    {
  438.       PPRVSTDAPP pPrvStdApp;
  439.  
  440.       pPrvStdApp = pPubStdApp->pv;
  441.       if ( pPrvStdApp->hab )
  442.          hab = pPrvStdApp->hab;
  443.    }
  444.  
  445.    return hab;
  446. }
  447.  
  448. HPS APIENTRY
  449. QueryHpsStdApp( PPUBSTDAPP pPubStdApp )
  450. {
  451.    HPS hps = (HPS)0;
  452.  
  453.    if ( pPubStdApp && pPubStdApp->pv )
  454.    {
  455.       PPRVSTDAPP pPrvStdApp;
  456.  
  457.       pPrvStdApp = pPubStdApp->pv;
  458.  
  459.       if ( pPrvStdApp->hpsClient )
  460.          hps = pPrvStdApp->hpsClient;
  461.    }
  462.  
  463.    return hps;
  464. }
  465.  
  466.  
  467. HWND APIENTRY
  468. QueryClientStdApp( PPUBSTDAPP pPubStdApp )
  469. {
  470.    HWND hClient = (HWND)0;
  471.  
  472.    if ( pPubStdApp && pPubStdApp->pv )
  473.    {
  474.       PPRVSTDAPP pPrvStdApp;
  475.  
  476.       pPrvStdApp = pPubStdApp->pv;
  477.  
  478.       if ( pPrvStdApp->hClient )
  479.          hClient = pPrvStdApp->hClient;
  480.    }
  481.  
  482.    return hClient;
  483. }
  484.  
  485.  
  486. BOOL APIENTRY
  487. QueryDevResStdApp( PPUBSTDAPP pPubStdApp, PULONG pulXRes
  488.                  , PULONG pulYRes )
  489. {
  490.    BOOL  fRc = API_FAILED;
  491.  
  492.    if ( pPubStdApp && pPubStdApp->pv )
  493.    {
  494.       PPRVSTDAPP pPrvStdApp;
  495.  
  496.       pPrvStdApp = pPubStdApp->pv;
  497.       if ( pPrvStdApp )
  498.       {
  499.          *pulXRes  = pPrvStdApp->cxRes;
  500.          *pulYRes  = pPrvStdApp->cyRes;
  501.          fRc       = API_SUCCESS;
  502.       }
  503.    }
  504.  
  505.    return fRc;
  506. }
  507.  
  508. BOOL APIENTRY
  509. QueryDevColorStdApp( PPUBSTDAPP pPubStdApp, PULONG pulColorPlanes
  510.                    , PULONG pulColorBitcount )
  511. {
  512.    BOOL  fRc = API_FAILED;
  513.  
  514.    if ( pPubStdApp && pPubStdApp->pv )
  515.    {
  516.       PPRVSTDAPP pPrvStdApp;
  517.  
  518.       pPrvStdApp         = pPubStdApp->pv;
  519.       *pulColorPlanes    = pPrvStdApp->cColorPlanes;
  520.       *pulColorBitcount  = pPrvStdApp->cColorBitcount;
  521.       fRc     = API_SUCCESS;
  522.    }
  523.  
  524.    return fRc;
  525. }
  526.  
  527. HWND APIENTRY
  528. QueryFrameStdApp( PPUBSTDAPP pPubStdApp )
  529. {
  530.    HWND hFrame = (HWND)0;
  531.  
  532.    if ( pPubStdApp && pPubStdApp->pv )
  533.    {
  534.       PPRVSTDAPP pPrvStdApp;
  535.  
  536.       pPrvStdApp = pPubStdApp->pv;
  537.  
  538.       if ( pPrvStdApp->hFrame )
  539.          hFrame = pPrvStdApp->hFrame;
  540.    }
  541.  
  542.    return hFrame;
  543. }
  544.  
  545. MRESULT
  546. InitMenuStdApp(HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2)
  547. {
  548.    PPUBSTDAPP pPubStdApp = WinQueryWindowPtr(hwnd, STDAPP_PTR_INDEX);
  549.    MRESULT    mr         = 0;
  550.  
  551.    switch( SHORT1FROMMP(mp1) )
  552.    {
  553.       case STDAPP_IDM_HELP:
  554.       {
  555.          if ( pPubStdApp && pPubStdApp->pv )
  556.          {
  557.             PPRVSTDAPP pPrvStdApp = pPubStdApp->pv;
  558.             BOOL       fEnable;
  559.  
  560.             // Enable or disable the Help menu depending upon whether the
  561.             // help manager has been enabled
  562.             fEnable = (pPrvStdApp->flServices & STDAPP_SERVICE_HELP);
  563.             if ( fEnable )
  564.             {
  565.                EnableMenuItemStdApp( HWNDFROMMP(mp2)
  566.                                    , STDAPP_IDM_HELPUSINGHELP
  567.                                    , fEnable );
  568.  
  569.                EnableMenuItemStdApp( HWNDFROMMP(mp2)
  570.                                    , STDAPP_IDM_HELPGENERAL
  571.                                    , fEnable );
  572.  
  573.                EnableMenuItemStdApp( HWNDFROMMP(mp2)
  574.                                    , STDAPP_IDM_HELPKEYS
  575.                                    , fEnable );
  576.  
  577.                EnableMenuItemStdApp( HWNDFROMMP(mp2)
  578.                                    , STDAPP_IDM_HELPINDEX
  579.                                    , fEnable );
  580.             }
  581.          }
  582.          break;
  583.       }
  584.  
  585.       default:
  586.          break;
  587.    }
  588.  
  589.    return mr;
  590.  
  591. }   //       End of WndStdInitMenu()
  592.  
  593.  
  594.  
  595.  
  596.  
  597. MRESULT
  598. CommandStdApp(HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2)
  599. {
  600.    MRESULT    mr = 0;
  601.    PPUBSTDAPP pPubStdApp = WinQueryWindowPtr(hwnd, STDAPP_PTR_INDEX);
  602.  
  603.    if ( pPubStdApp && pPubStdApp->pv )
  604.    {
  605.       PPRVSTDAPP pPrvStdApp = pPubStdApp->pv;
  606.  
  607.       switch(SHORT1FROMMP(mp1))
  608.       {
  609.          case STDAPP_IDM_EXIT:
  610.          {
  611.             BOOL fQuit = TRUE;
  612.  
  613.             if ( pPrvStdApp->flServices & STDAPP_SERVICE_CONFIRM_EXIT )
  614.             {
  615.                UtlSubsitiuteStrings( pPrvStdApp->hab
  616.                                    , pPrvStdApp->hmodDll
  617.                                    , IDMSG_CONFIRMEXITOF
  618.                                    , pPrvStdApp->szText1
  619.                                    , pPrvStdApp->szTitle);
  620.  
  621.                if ( (UtlUserMsgBox( pPrvStdApp->szText1
  622.                                   , pPrvStdApp->szStdAppService
  623.                                   , MB_YESNO | MB_DEFBUTTON2 | MB_ICONQUESTION   //MB_QUERY
  624.                                   , FALSE
  625.                                   , 0 )) == MBID_NO )
  626.                   fQuit = FALSE;
  627.  
  628.             }
  629.  
  630.             if ( fQuit )
  631.                WinPostMsg( hwnd, WM_QUIT, (MPARAM)0, (MPARAM)0 );
  632.  
  633.             break;
  634.          }
  635.  
  636.          case STDAPP_IDM_HELPUSINGHELP:
  637.          {
  638.             HlpUsingHelp(pPrvStdApp);
  639.             break;
  640.          }
  641.  
  642.          case STDAPP_IDM_HELPGENERAL:
  643.          {
  644.             HlpGeneral(pPrvStdApp);
  645.             break;
  646.          }
  647.  
  648.          case STDAPP_IDM_HELPKEYS:
  649.          {
  650.             HlpKeys(pPrvStdApp);
  651.             break;
  652.          }
  653.  
  654.          case STDAPP_IDM_HELPINDEX:
  655.          {
  656.             HlpIndex(pPrvStdApp);
  657.             break;
  658.          }
  659.  
  660.          default:
  661.          {
  662.             // User command processing routine is called
  663.             // here so any ids not procecessed here can be
  664.             // processed
  665.  
  666.             pPrvStdApp = pPubStdApp->pv;
  667.             mr         = pPrvStdApp->pfnUserProc(hwnd, msg, mp1, mp2) ;
  668.          }
  669.       }
  670.    }
  671.  
  672.    return mr;
  673. }  // End of CommandStdApp()
  674.  
  675.  
  676.  
  677.  
  678.  
  679. VOID  APIENTRY
  680. EnableMenuItemStdApp( HWND hwndMenu, SHORT sIditem, BOOL bEnable)
  681. {
  682.   SHORT sFlag;
  683.  
  684.   if( bEnable )
  685.     sFlag = 0;
  686.   else
  687.     sFlag = MIA_DISABLED;
  688.  
  689.  
  690.   WinSendMsg( hwndMenu
  691.             , MM_SETITEMATTR
  692.             , MPFROM2SHORT(sIditem, TRUE)
  693.             , MPFROM2SHORT(MIA_DISABLED, sFlag));
  694.  
  695. } // End of EnableMenuItemStdApp()
  696.  
  697.  
  698.  
  699.  
  700.  
  701.  
  702.  
  703. BOOL
  704. ValidateMenuServiceStdApp( PPRVSTDAPP pPrvStdApp )
  705. {
  706.    BOOL   fRc=API_SUCCESS;
  707.  
  708.    if ( (fRc=ValidateMenuStdApp(pPrvStdApp)) == API_SUCCESS )
  709.    {
  710.       BOOL   fExitRc;
  711.       BOOL   fHelpRc;
  712.  
  713.       if ( (fExitRc=ValidateMenuExitStdApp(pPrvStdApp)) == API_FAILED )
  714.          pPrvStdApp->flServices &= ~( STDAPP_SERVICE_CONFIRM_EXIT );
  715.  
  716.       if ( (fHelpRc=ValidateMenuHelpStdApp(pPrvStdApp)) == API_FAILED )
  717.          pPrvStdApp->flServices &= ~( STDAPP_SERVICE_HELP );
  718.  
  719.       if ( fExitRc == API_FAILED || fHelpRc == API_FAILED )
  720.          fRc = API_FAILED;
  721.    }
  722.    else
  723.    {
  724.       pPrvStdApp->flServices &= ~( STDAPP_SERVICE_HELP
  725.                                  | STDAPP_SERVICE_CONFIRM_EXIT );
  726.       fRc = API_FAILED;
  727.    }
  728.    return fRc;
  729. }
  730.  
  731.  
  732.  
  733.  
  734.  
  735. BOOL
  736. ValidateMenuStdApp( PPRVSTDAPP pPrvStdApp )
  737. {
  738. static MT mt;
  739.  
  740.    USHORT   usMsgStyle = MB_CUAWARNING | MB_SYSTEMMODAL | MB_ENTER;
  741.    BOOL     fRc = API_SUCCESS;
  742.  
  743.    pPrvStdApp->hMenu = WinWindowFromID( pPrvStdApp->hFrame, FID_MENU);
  744.  
  745.    if ( !pPrvStdApp->hMenu )
  746.    {
  747.       if ( !mt.cb )
  748.          mt.cb = sizeof(mt);
  749.  
  750.       pPrvStdApp->hMenu = WinCreateMenu( pPrvStdApp->hFrame, &mt );
  751.  
  752.       if ( !pPrvStdApp->hMenu )
  753.       {
  754.          UtlLoadMessage( pPrvStdApp->hab
  755.                        , pPrvStdApp->hmodDll
  756.                        , IDMSG_ACTBARCREATEERR
  757.                        , STDAPP_TEXT_LENGTH
  758.                        , pPrvStdApp->szText1 );
  759.  
  760.          UtlUserMsgBox( pPrvStdApp->szText1
  761.                       , pPrvStdApp->szStdAppService
  762.                       , usMsgStyle
  763.                       , FALSE
  764.                       , 0 );
  765.  
  766.       fRc = API_FAILED;
  767.  
  768.       }
  769.       else
  770.          WinSendMsg( pPrvStdApp->hFrame
  771.                    , WM_UPDATEFRAME
  772.                    , MPFROMLONG(FCF_MENU)
  773.                    , MPFROMLONG(0) );
  774.    }
  775.  
  776.    return fRc;
  777. }
  778.  
  779.  
  780. BOOL
  781. ValidateMenuExitStdApp( PPRVSTDAPP pPrvStdApp )
  782. {
  783.  
  784.    MENUITEM mi;
  785.    USHORT   usMsgStyle = MB_CUAWARNING | MB_SYSTEMMODAL | MB_ENTER;
  786.    SHORT    sRc;
  787.    BOOL     fRc = API_FAILED;
  788.  
  789.    if ( pPrvStdApp->flServices & STDAPP_SERVICE_CONFIRM_EXIT )
  790.    {
  791.       // To confirm exit there should be an Exit Menu Item
  792.       fRc = (BOOL)WinSendMsg( pPrvStdApp->hMenu
  793.                             , MM_QUERYITEM
  794.                             , MPFROM2SHORT(STDAPP_IDM_EXIT,TRUE)
  795.                             , &mi );
  796.  
  797.       if ( !fRc )
  798.       {
  799.          static PSZ apszExit[] = {
  800.                                  EXIT_MENU_TEXT
  801.                                  };
  802.  
  803.          static MENUITEM amiExit[] = {
  804.                 {MIT_END, MIS_SUBMENU, 0, STDAPP_IDM_EXIT, (HWND)0, (ULONG)0}
  805.                                      };
  806.  
  807.          amiExit[0].hwndSubMenu = WinCreateWindow( pPrvStdApp->hClient
  808.                                                  , WC_MENU
  809.                                                  , apszExit[0]
  810.                                                  , WS_VISIBLE
  811.                                                  , 0
  812.                                                  , 0
  813.                                                  , 0
  814.                                                  , 0
  815.                                                  , pPrvStdApp->hMenu
  816.                                                  , HWND_TOP
  817.                                                  , amiExit[0].id
  818.                                                  , (PVOID)0
  819.                                                  , (PVOID)0 );
  820.  
  821.          if ( amiExit[0].hwndSubMenu )
  822.          {
  823.  
  824.          WinSendMsg( pPrvStdApp->hFrame
  825.                    , WM_UPDATEFRAME
  826.                    , MPFROMLONG(FCF_MENU)
  827.                    , MPFROMLONG(0) );
  828.  
  829.             sRc = (SHORT)WinSendMsg( pPrvStdApp->hMenu
  830.                                   , MM_INSERTITEM
  831.                                   , MPFROMP(&amiExit[0])
  832.                                   , MPFROMP(apszExit[0]) );
  833.  
  834.             fRc = API_SUCCESS;
  835.             if ( sRc == MIT_MEMERROR || sRc == MIT_ERROR )
  836.             {
  837.  
  838.                UtlLoadMessage( pPrvStdApp->hab
  839.                              , pPrvStdApp->hmodDll
  840.                              , IDMSG_ADDHLPSUBMENUWIN
  841.                              , STDAPP_TEXT_LENGTH
  842.                              , pPrvStdApp->szText1 );
  843.  
  844.                UtlUserMsgBox( pPrvStdApp->szText1
  845.                             , pPrvStdApp->szStdAppService
  846.                             , usMsgStyle
  847.                             , FALSE
  848.                             , 0 );
  849.  
  850.                fRc = API_FAILED;
  851.  
  852.             } // end if ( sRc == MIT_MEMERROR || sRc == MIT_ERROR )
  853.             else
  854.                fRc = API_SUCCESS;
  855.  
  856.          }    // end  if ( amiExit[0].hwndSubMenu )
  857.          else
  858.          {
  859.             UtlLoadMessage( pPrvStdApp->hab
  860.                           , pPrvStdApp->hmodDll
  861.                           , IDMSG_CREATEEXITSUBMENUWIN
  862.                           , STDAPP_TEXT_LENGTH
  863.                           , pPrvStdApp->szText1 );
  864.  
  865.             UtlUserMsgBox( pPrvStdApp->szText1
  866.                          , pPrvStdApp->szStdAppService
  867.                          , usMsgStyle
  868.                          , FALSE
  869.                          , 0 );
  870.          }
  871.  
  872.       }       // end exit item does not exist
  873.       else
  874.          fRc = API_SUCCESS;
  875.  
  876.    }          // end if ( pPrvStdApp->flServices & STDAPP_SERVICE_CONFIRM_EXIT)
  877.  
  878.    if ( fRc == API_SUCCESS )
  879.    {
  880.       HWND hSysMenu;
  881.  
  882.       hSysMenu =  WinWindowFromID( pPrvStdApp->hFrame, FID_SYSMENU );
  883.  
  884.       if ( hSysMenu ) // with confirm on exit ACTIONBAR Exit is only way out.
  885.          EnableMenuItemStdApp( hSysMenu, SC_CLOSE, FALSE);
  886.  
  887.    } // end if ( fRc == API_SUCCESS )
  888.  
  889.    return fRc;
  890.  
  891. }  // end ValidateMenuExitStdApp( PPRVSTDAPP pPrvStdApp )
  892.  
  893.  
  894.  
  895.  
  896.  
  897. BOOL
  898. ValidateMenuHelpStdApp( PPRVSTDAPP pPrvStdApp )
  899. {
  900.    MENUITEM mi;
  901.    USHORT   usMsgStyle = MB_CUAWARNING | MB_SYSTEMMODAL | MB_ENTER;
  902.    SHORT    sRc;
  903.    BOOL     fRc = API_FAILED;
  904.  
  905.    static PSZ apszHelp[] = {
  906.                            HELP_MENU_TEXT,
  907.                            HELP_INDEX_TEXT,
  908.                            HELP_GENERAL_TEXT,
  909.                            HELP_KEYS_TEXT,
  910.                            HELP_USING_TEXT
  911.                            };
  912.  
  913.    static MENUITEM amiHelp[] = {
  914.    {MIT_END, MIS_SUBMENU, 0, STDAPP_IDM_HELP,          (HWND)0, (ULONG)0},
  915.    {MIT_END, MIS_TEXT,    0, STDAPP_IDM_HELPINDEX,     (HWND)0, (ULONG)0},
  916.    {MIT_END, MIS_TEXT,    0, STDAPP_IDM_HELPGENERAL,   (HWND)0, (ULONG)0},
  917.    {MIT_END, MIS_TEXT,    0, STDAPP_IDM_HELPKEYS,      (HWND)0, (ULONG)0},
  918.    {MIT_END, MIS_TEXT,    0, STDAPP_IDM_HELPUSINGHELP, (HWND)0, (ULONG)0}};
  919.  
  920.    // Check if user supplied Help menu item
  921.    fRc = (BOOL)WinSendMsg( pPrvStdApp->hMenu
  922.                          , MM_QUERYITEM
  923.                          , MPFROM2SHORT(STDAPP_IDM_HELP,TRUE)
  924.                          , &mi );
  925.  
  926.    if ( fRc )
  927.    {
  928.       HlpInitHelp(pPrvStdApp);
  929.       fRc = API_SUCCESS;
  930.    }
  931.    else  // No User Provided Help
  932.    {
  933.       amiHelp[0].hwndSubMenu = WinCreateWindow( pPrvStdApp->hClient
  934.                                               , WC_MENU
  935.                                               , apszHelp[0]
  936.                                               , WS_VISIBLE
  937.                                               , 0
  938.                                               , 0
  939.                                               , 0
  940.                                               , 0
  941.                                               , pPrvStdApp->hMenu
  942.                                               , HWND_TOP
  943.                                               , amiHelp[0].id
  944.                                               , (PVOID)0
  945.                                               , (PVOID)0 );
  946.  
  947.       if ( amiHelp[0].hwndSubMenu )
  948.       {
  949.          sRc = (SHORT)WinSendMsg( pPrvStdApp->hMenu
  950.                                   , MM_INSERTITEM
  951.                                   , MPFROMP(&amiHelp[0])
  952.                                   , MPFROMP(apszHelp[0]) );
  953.          if ( sRc != MIT_MEMERROR && sRc != MIT_ERROR )
  954.          {
  955.             SHORT sMax = (STDAPP_IDM_HELP - STDAPP_IDM_HELPUSINGHELP) + 1;
  956.             SHORT i;
  957.  
  958.             fRc = API_SUCCESS;
  959.  
  960.             // add menuitem(s) to submenu window
  961.             for (i=1; i <sMax; i++)
  962.             {
  963.                 sRc = (SHORT)WinSendMsg( amiHelp[0].hwndSubMenu
  964.                                          , MM_INSERTITEM
  965.                                          , MPFROMP(&amiHelp[i])
  966.                                          , MPFROMP(apszHelp[i]) );
  967.  
  968.                 if ( sRc == MIT_MEMERROR || sRc == MIT_ERROR )
  969.                 {
  970.                    UtlLoadMessage( pPrvStdApp->hab
  971.                                  , pPrvStdApp->hmodDll
  972.                                  , IDMSG_ADDHLPSUBMENUWIN
  973.                                  , STDAPP_TEXT_LENGTH
  974.                                  , pPrvStdApp->szText1 );
  975.  
  976.                    UtlUserMsgBox( pPrvStdApp->szText1
  977.                                 , pPrvStdApp->szStdAppService
  978.                                 , usMsgStyle
  979.                                 , FALSE
  980.                                 , 0 );
  981.                    fRc = API_FAILED;
  982.                    break;
  983.                 } // end if ( sRc == MIT_MEMERROR || sRc == MIT_ERROR )
  984.  
  985.             WinSendMsg( pPrvStdApp->hFrame
  986.                       , WM_UPDATEFRAME
  987.                       , MPFROMLONG(FCF_MENU)
  988.                       , MPFROMLONG(0) );
  989.  
  990.             } // end for (i=1; i <sMax; i++)
  991.  
  992.             if ( fRc != API_FAILED )
  993.                HlpInitHelp(pPrvStdApp);
  994.  
  995.          }  // end if ( sRc != MIT_MEMERROR && sRc != MIT_ERROR )
  996.          else
  997.          {
  998.             UtlLoadMessage( pPrvStdApp->hab
  999.                           , pPrvStdApp->hmodDll
  1000.                           , IDMSG_CREATEHLPSUBMENUWIN
  1001.                           , STDAPP_TEXT_LENGTH
  1002.                           , pPrvStdApp->szText1 );
  1003.  
  1004.             UtlUserMsgBox( pPrvStdApp->szText1
  1005.                          , pPrvStdApp->szStdAppService
  1006.                          , usMsgStyle
  1007.                          , FALSE
  1008.                          , 0 );
  1009.  
  1010.             fRc = API_FAILED;
  1011.          }
  1012.  
  1013.       }  // end if ( amiHelp[0].hwndSubMenu )
  1014.  
  1015.       else
  1016.       {
  1017.          UtlUserMsgBox( pPrvStdApp->szText1
  1018.                       , pPrvStdApp->szStdAppService
  1019.                       , usMsgStyle
  1020.                       , FALSE
  1021.                       , 0 );
  1022.  
  1023.          fRc = API_FAILED;
  1024.       }
  1025.  
  1026.    }     // end else No User Provided Help
  1027.  
  1028.    return fRc;
  1029.  
  1030. }  // end ValidateMenuHelpStdApp( PPRVSTDAPP pPrvStdApp )
  1031.  
  1032.  
  1033.  
  1034.  
  1035.  
  1036.  
  1037.  
  1038.  
  1039.  
  1040. VOID APIENTRY
  1041. HlpInitHelp( PPRVSTDAPP pPrvStdApp )
  1042. {
  1043.   HELPINIT helpInit;
  1044.   BOOL     fRc;
  1045.  
  1046.   // if we return because of an error, Help will be disabled
  1047.  
  1048.   if ( !pPrvStdApp )
  1049.      return;
  1050.  
  1051.  
  1052.  
  1053.   // inititalize help init structure
  1054.   helpInit.cb                       = sizeof(HELPINIT);
  1055.   helpInit.ulReturnCode             = 0L;
  1056.  
  1057.   helpInit.pszTutorialName          = (PSZ)NULL;
  1058.   helpInit.phtHelpTable             = (PHELPTABLE)MAKELONG( STDAPP_HELP_TABLE,
  1059.                                                             0xFFFF);
  1060.   if ( pPrvStdApp->hmodDll )
  1061.      helpInit.hmodHelpTableModule   = pPrvStdApp->hmodDll;
  1062.   else
  1063.      helpInit.hmodHelpTableModule   = (HMODULE)0;
  1064.  
  1065.   helpInit.hmodAccelActionBarModule = (HMODULE)0;
  1066.   helpInit.idAccelTable             = 0;
  1067.   helpInit.idActionBar              = 0;
  1068.  
  1069.  
  1070.   fRc = UtlLoadString( pPrvStdApp->hab
  1071.                      , pPrvStdApp->hmodExe
  1072.                      , STDAPP_IDS_HELPWINDOWTITLE
  1073.                      , MAXNAMEL
  1074.                      , (PSZ)pPrvStdApp->szWindowTitle);
  1075.  
  1076.   if ( fRc == API_FAILED)
  1077.      goto ErrorDrain;
  1078.  
  1079.  
  1080.   helpInit.pszHelpWindowTitle = (PSZ)pPrvStdApp->szWindowTitle;
  1081.  
  1082.   helpInit.fShowPanelId = CMIC_HIDE_PANEL_ID;
  1083.  
  1084.  
  1085.   fRc = UtlLoadString( pPrvStdApp->hab
  1086.                      , pPrvStdApp->hmodExe
  1087.                      , STDAPP_IDS_HELPLIBRARYNAME
  1088.                      , CCHMAXPATH
  1089.                      , (PSZ)pPrvStdApp->szLibName);
  1090.  
  1091.   if ( fRc == API_FAILED)
  1092.      goto ErrorDrain;
  1093.  
  1094.  
  1095.   helpInit.pszHelpLibraryName = (PSZ)pPrvStdApp->szLibName;
  1096.  
  1097.   // creating help instance
  1098.   pPrvStdApp->hHelpInstance = WinCreateHelpInstance(pPrvStdApp->hab, &helpInit);
  1099.  
  1100.   if (!pPrvStdApp->hHelpInstance || helpInit.ulReturnCode)
  1101.   {
  1102.     fRc = UtlLoadMessage( pPrvStdApp->hab
  1103.                         , pPrvStdApp->hmodDll
  1104.                         , IDMSG_HELPLOADERROR
  1105.                         , STDAPP_TEXT_LENGTH
  1106.                         , (PSZ)pPrvStdApp->szText1);
  1107.  
  1108.     if ( fRc == API_SUCCESS)
  1109.        UtlDisplayError(pPrvStdApp->hab, (PSZ)pPrvStdApp->szText1);
  1110.  
  1111.     goto ErrorDrain;
  1112.   }
  1113.  
  1114.  
  1115.   // associate help instance with  frame
  1116.   fRc = (BOOL)WinAssociateHelpInstance( pPrvStdApp->hHelpInstance
  1117.                                       , pPrvStdApp->hFrame);
  1118.   if (!fRc )
  1119.   {
  1120.     fRc = UtlLoadMessage( pPrvStdApp->hab
  1121.                         , pPrvStdApp->hmodDll
  1122.                         , IDMSG_HELPLOADERROR
  1123.                         , STDAPP_TEXT_LENGTH
  1124.                         , (PSZ)pPrvStdApp->szText1);
  1125.  
  1126.     if ( fRc == API_SUCCESS)
  1127.       UtlDisplayError(pPrvStdApp->hab, (PSZ)pPrvStdApp->szText1);
  1128.  
  1129.     goto ErrorDrain;
  1130.   }
  1131.  
  1132.   return;
  1133.  
  1134. ErrorDrain:
  1135.  
  1136.   pPrvStdApp->flServices &= ~(STDAPP_SERVICE_HELP);
  1137.  
  1138. }   // End of HlpInitHelp()
  1139.  
  1140.  
  1141.  
  1142.  
  1143. VOID APIENTRY
  1144. HlpUsingHelp(PPRVSTDAPP pPrvStdApp)
  1145. {
  1146.    BOOL fRc;
  1147.  
  1148. //    this just displays the system help for help panel
  1149.     fRc =(BOOL)WinSendMsg( pPrvStdApp->hHelpInstance
  1150.                          , HM_DISPLAY_HELP
  1151.                          , 0
  1152.                          , 0);
  1153.     if ( fRc )
  1154.       UtlMsgBox( pPrvStdApp->hab
  1155.                , pPrvStdApp->hmodDll
  1156.                , IDMSG_HELPDISPLAYERROR
  1157.                , MB_ENTER | MB_ERROR, TRUE);
  1158. }   // End of HlpUsingHelp()
  1159.  
  1160.  
  1161.  
  1162.  
  1163. VOID APIENTRY
  1164. HlpGeneral(PPRVSTDAPP pPrvStdApp)
  1165. {
  1166.    BOOL fRc;
  1167.  
  1168. //   this just displays the system General help panel
  1169.      fRc = (BOOL)WinSendMsg( pPrvStdApp->hHelpInstance
  1170.                            , HM_EXT_HELP
  1171.                            , 0
  1172.                            , 0);
  1173.      if ( fRc )
  1174.          UtlMsgBox( pPrvStdApp->hab
  1175.                   , pPrvStdApp->hmodDll
  1176.                   , IDMSG_HELPDISPLAYERROR
  1177.                   , MB_ENTER | MB_ERROR, TRUE);
  1178. }       // End of HlpGeneral()
  1179.  
  1180.  
  1181.  
  1182.  
  1183. VOID APIENTRY
  1184. HlpKeys(PPRVSTDAPP pPrvStdApp)
  1185. {
  1186.    BOOL fRc;
  1187.  
  1188. // this just displays the system keys help panel
  1189.     fRc = (BOOL)WinSendMsg( pPrvStdApp->hHelpInstance
  1190.                           , HM_KEYS_HELP
  1191.                           , 0
  1192.                           , 0);
  1193.     if ( fRc )
  1194.       UtlMsgBox( pPrvStdApp->hab
  1195.                , pPrvStdApp->hmodDll
  1196.                , IDMSG_HELPDISPLAYERROR
  1197.                , MB_ENTER | MB_ERROR, TRUE);
  1198. }   //   End of HlpKeys()
  1199.  
  1200.  
  1201.  
  1202.  
  1203. VOID APIENTRY
  1204. HlpIndex(PPRVSTDAPP pPrvStdApp)
  1205. {
  1206.    BOOL fRc;
  1207.  
  1208. // this just displays the system help index panel
  1209.     fRc = (BOOL)WinSendMsg( pPrvStdApp->hHelpInstance
  1210.                           , HM_HELP_INDEX
  1211.                           , 0
  1212.                           , 0);
  1213.     if ( fRc )
  1214.       UtlMsgBox( pPrvStdApp->hab
  1215.                , pPrvStdApp->hmodDll
  1216.                , IDMSG_HELPDISPLAYERROR
  1217.                , MB_ENTER | MB_ERROR, TRUE);
  1218. }   // End of HlpIndex()
  1219.  
  1220.  
  1221.  
  1222.  
  1223. VOID
  1224. HlpDisplayHelpPanel(PPRVSTDAPP pPrvStdApp, SHORT idPanel)
  1225. {
  1226.    BOOL fRc;
  1227.  
  1228.    fRc = (BOOL)WinSendMsg( pPrvStdApp->hHelpInstance
  1229.                          , HM_DISPLAY_HELP
  1230.                          , MPFROM2SHORT(idPanel, 0)
  1231.                          , MPFROMSHORT(HM_RESOURCEID) );
  1232.    if ( fRc )
  1233.      UtlMsgBox( pPrvStdApp->hab
  1234.               , pPrvStdApp->hmodDll
  1235.               , IDMSG_HELPDISPLAYERROR
  1236.               , MB_ENTER | MB_ERROR, TRUE);
  1237. }  //    End of HlpDisplayHelpPanel()
  1238.  
  1239.  
  1240.  
  1241. VOID APIENTRY
  1242. HlpDestroyHelpInstance(PPRVSTDAPP pPrvStdApp)
  1243. {
  1244.   if (pPrvStdApp->flServices &    STDAPP_SERVICE_HELP)
  1245.   {
  1246.      pPrvStdApp->flServices  &= ~(STDAPP_SERVICE_HELP);
  1247.      WinDestroyHelpInstance(pPrvStdApp->hHelpInstance);
  1248.   }
  1249. }   //        End of HlpDestroyHelpInstance()
  1250.  
  1251.  
  1252.  
  1253.  
  1254.  
  1255.  
  1256.  
  1257.  
  1258.  
  1259.  
  1260.  
  1261.  
  1262.  
  1263.  
  1264.